packages/react/runtime/lepus/hooks/index.js (1)

60-68: useReducer dispatch is a no-op - state updates won't work.

The dispatch function on line 64 is function(action) {}, which silently discards all state updates. If this is intentional for a single-render main-thread context (matching the no-op useEffect/useLayoutEffect), consider adding a brief comment to document this design choice for maintainability.

📝 Suggested documentation

 function useReducer(reducer, initialState, init) {
   var hookState = getHookState(currentIndex++, 2);
   hookState._reducer = reducer;
   if (!hookState[COMPONENT]) {
+    // Dispatch is no-op in main-thread runtime (single render, no state updates)
     hookState[VALUE] = [!init ? invokeOrReturn(undefined, initialState) : init(initialState), function(action) {}];
     hookState[COMPONENT] = currentComponent;
   }
   return hookState[VALUE];
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/react/runtime/lepus/hooks/index.js` around lines 60 - 68,
useReducer's dispatch is currently a no-op (function(action) {}), so state never
updates; replace that no-op with a dispatch that uses hookState._reducer to
compute the next state, assigns it into hookState[VALUE][0], and triggers the
component update via the runtime's render scheduler (use currentComponent or
whatever local scheduler API is available) so the component re-renders with the
new state; if the no-op was intentional, instead add a one-line comment inside
useReducer next to the dispatch (referencing useReducer, hookState,
hookState._reducer, hookState[VALUE], currentComponent) explaining the
single-render/main-thread design decision.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

packages/react/runtime/lepus/hooks/index.js (1)

118-122: ⚠️ Potential issue | 🔴 Critical

useId still returns the same ID for every call.

mask is recreated on each invocation, so mask[1]++ always starts from 0 and every component gets P0-0.

Proposed fix

+var idMask = [0, 0];
+
 function useId() {
   var state = getHookState(currentIndex++, 11);
-  var mask = [0, 0];
-  state[VALUE] = 'P' + mask[0] + '-' + mask[1]++;
+  if (state[VALUE] == null) {
+    state[VALUE] = 'P' + idMask[0] + '-' + idMask[1]++;
+  }
   return state[VALUE];
 }

In React and Preact, should `useId` return a stable unique ID per hook call rather than the same ID for every component?

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/react/runtime/lepus/hooks/index.js` around lines 118 - 122, useId
currently recreates mask on every call so every hook returns "P0-0"; fix by
making the ID persistent in the hook state instead of recomputing: inside useId
(which calls getHookState and uses currentIndex and VALUE) only compute and
assign state[VALUE] when it's not already set — e.g. initialize a stable
per-hook counter or store the mask/counter in the returned state array so
subsequent calls reuse it (use getHookState's state slot rather than local var
mask) and increment a module-level counter or the stored counter when generating
new IDs.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

packages/react/runtime/lepus/hooks/index.js (3)

60-67: ⚠️ Potential issue | 🔴 Critical

useReducer dispatch is still a no-op, so state updates are dropped.

On Line 64, the dispatcher never calls reducer, never writes next state, and never schedules a render. This breaks both useReducer and useState update flow.

🐛 Proposed fix

 function useReducer(reducer, initialState, init) {
   var hookState = getHookState(currentIndex++, 2);
   hookState._reducer = reducer;
   if (!hookState[COMPONENT]) {
-    hookState[VALUE] = [!init ? invokeOrReturn(undefined, initialState) : init(initialState), function(action) {}];
+    hookState[VALUE] = [!init ? invokeOrReturn(undefined, initialState) : init(initialState), function(action) {
+      var currentValue = hookState[VALUE][0];
+      var nextValue = hookState._reducer(currentValue, action);
+      if (!Object.is(currentValue, nextValue)) {
+        hookState[VALUE][0] = nextValue;
+        hookState[COMPONENT].setState({});
+      }
+    }];
     hookState[COMPONENT] = currentComponent;
   }
   return hookState[VALUE];
 }

In Preact hooks, what does the `dispatch` function returned by `useReducer` do when next state differs from current state?

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/react/runtime/lepus/hooks/index.js` around lines 60 - 67, The
dispatch returned from useReducer is a no-op; change the inline dispatch (the
second element of hookState[VALUE]) to accept an action, obtain the current
state from hookState[VALUE][0], compute nextState by calling
hookState._reducer(currentState, action), compare nextState to currentState
(strict equality), and if different assign hookState[VALUE][0] = nextState and
schedule a component update (call the framework's render/enqueue update helper
for currentComponent) so the component re-renders; ensure you reference
hookState._reducer, hookState[VALUE], and currentComponent when implementing
this.

---

84-87: ⚠️ Potential issue | 🔴 Critical

useMemo ignores dependencies and recomputes every render.

Lines 84-87 always call factory(). This breaks memoization and invalidates useCallback/useRef stability guarantees.

🐛 Proposed fix

 function useMemo(factory, args) {
   var state = getHookState(currentIndex++, 7);
-  state[VALUE] = factory();
+  if (!args || !state._args || argsChanged(state._args, args)) {
+    state[VALUE] = factory();
+    state._args = args;
+  }
   return state[VALUE];
 }
+
+function argsChanged(oldArgs, newArgs) {
+  if (oldArgs.length !== newArgs.length) return true;
+  for (var i = 0; i < oldArgs.length; i++) {
+    if (!Object.is(oldArgs[i], newArgs[i])) return true;
+  }
+  return false;
+}

In current Preact hooks, does `useMemo` reuse cached value when dependency values are unchanged, and are `useCallback`/`useRef` implemented on top of that behavior?

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/react/runtime/lepus/hooks/index.js` around lines 84 - 87, useMemo
currently always calls factory() and ignores dependencies; change useMemo (the
function using getHookState and currentIndex) to read the previous deps from the
hook state, perform a shallow equality check between prevDeps and the incoming
args, and only call factory() and update state[VALUE] when args are provided and
differ (if args is undefined, preserve existing React/Preact semantics and
recompute every render). Store the new deps into the hook state (e.g.,
state[DEPS] or state[1]) after computing so subsequent renders can compare; this
will restore memoization used by useCallback/useRef which depend on stable
values from useMemo. Ensure the comparison checks length and each element with
=== (shallow).

---

118-123: ⚠️ Potential issue | 🔴 Critical

useId currently generates the same ID (P0-0) for all calls.

Line 120 recreates mask on each invocation, so Line 121 never advances globally and IDs are not unique.

🐛 Proposed fix

+var idMask = [0, 0];
+
 function useId() {
   var state = getHookState(currentIndex++, 11);
-  var mask = [0, 0];
-  state[VALUE] = 'P' + mask[0] + '-' + mask[1]++;
+  if (!state[VALUE]) {
+    state[VALUE] = 'P' + idMask[0] + '-' + idMask[1]++;
+  }
   return state[VALUE];
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/react/runtime/lepus/hooks/index.js` around lines 118 - 123, useId
currently creates a new local mask on each call so IDs never advance; persist
the counters instead of recreating mask each invocation by storing the
counter(s) in the hook state returned by getHookState (or in a module-level
counter) and update them when generating the ID. Specifically, in useId, read or
initialize a persistent counter from state (e.g., state.counter or state[VALUE]
slot), compute the ID using that counter (replacing the local mask),
increment/rollover the counters appropriately, assign the generated ID back to
state[VALUE], and return it so subsequent calls produce unique IDs.